{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: This example is compatible with versions v0.1.5 or lower, for the most recent version, see [this](https://github.com/facebookresearch/mbrl-lib/blob/main/notebooks/pets_example.ipynb) notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preview\n",
    "\n",
    "In this example, we are going to use our toolbox to write the [PETS](https://arxiv.org/pdf/1805.12114.pdf) algorithm (Chua at al., 2018), and use it to solve a continuous version of the cartpole environment. PETS is a model-based algorithm that consists of two main components: an ensemble of probabilistic models (each a feed-forward neural network), and a planner using the [Cross-Entropy Method](https://people.smp.uq.edu.au/DirkKroese/ps/aortut.pdf) (de Boer et al., 2004). \n",
    "\n",
    "A basic implementation of this algorithm consists of the following sequence of steps:\n",
    "\n",
    "1. Gather data using an exploration policy\n",
    "2. Repeat:<br>\n",
    "  2.1. Train the dynamics model using all available data.<br>\n",
    "  2.2. Do a trajectory on the environment, choosing actions with the planner, using the dynamics model to simulate environment transitions.\n",
    "  \n",
    "The ensemble model is trained to predict the environment's dynamics, and the planner tries to find high-reward trajectories over the model dynamics. \n",
    "\n",
    "To implement this using `MBRL-Lib`, we will use an ensemble of neural networks (NNs) modelling Gaussian distributions (available in the [mbrl.models](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.GaussianMLP) module), and a trajectory optimizer agent that uses CEM (available in the [mbrl.planning](https://luisenp.github.io/mbrl-lib/planning.html#mbrl.planning.TrajectoryOptimizerAgent) module). We will also rely on several of the utilities available in the [mbrl.util](https://luisenp.github.io/mbrl-lib/util.html) module. Finally, we will wrap the dynamics model into a [gym-like environment](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.ModelEnv) over which we can plan action sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import omegaconf\n",
    "\n",
    "import mbrl.env.cartpole_continuous as cartpole_env\n",
    "import mbrl.env.reward_fns as reward_fns\n",
    "import mbrl.env.termination_fns as termination_fns\n",
    "import mbrl.models as models\n",
    "import mbrl.planning as planning\n",
    "import mbrl.util.common as common_util\n",
    "import mbrl.util as util\n",
    "\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "mpl.rcParams.update({\"font.size\": 16})\n",
    "\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the environment\n",
    "\n",
    "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 0\n",
    "env = cartpole_env.CartPoleEnv()\n",
    "env.seed(seed)\n",
    "rng = np.random.default_rng(seed=0)\n",
    "generator = torch.Generator(device=device)\n",
    "generator.manual_seed(seed)\n",
    "obs_shape = env.observation_space.shape\n",
    "act_shape = env.action_space.shape\n",
    "\n",
    "# This functions allows the model to evaluate the true rewards given an observation \n",
    "reward_fn = reward_fns.cartpole\n",
    "# This function allows the model to know if an observation should make the episode end\n",
    "term_fn = termination_fns.cartpole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydra configuration\n",
    "\n",
    "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "trial_length = 200\n",
    "num_trials = 10\n",
    "ensemble_size = 5\n",
    "\n",
    "# Everything with \"???\" indicates an option with a missing value.\n",
    "# Our utility functions will fill in these details using the \n",
    "# environment information\n",
    "cfg_dict = {\n",
    "    # dynamics model configuration\n",
    "    \"dynamics_model\": {\n",
    "        \"model\": \n",
    "        {\n",
    "            \"_target_\": \"mbrl.models.GaussianMLP\",\n",
    "            \"device\": device,\n",
    "            \"num_layers\": 3,\n",
    "            \"ensemble_size\": ensemble_size,\n",
    "            \"hid_size\": 200,\n",
    "            \"in_size\": \"???\",\n",
    "            \"out_size\": \"???\",\n",
    "            \"deterministic\": False,\n",
    "            \"propagation_method\": \"fixed_model\",\n",
    "            # can also configure activation function for GaussianMLP\n",
    "            \"activation_fn_cfg\": {\n",
    "                \"_target_\": \"torch.nn.LeakyReLU\",\n",
    "                \"negative_slope\": 0.01\n",
    "            }\n",
    "        }\n",
    "    },\n",
    "    # options for training the dynamics model\n",
    "    \"algorithm\": {\n",
    "        \"learned_rewards\": False,\n",
    "        \"target_is_delta\": True,\n",
    "        \"normalize\": True,\n",
    "    },\n",
    "    # these are experiment specific options\n",
    "    \"overrides\": {\n",
    "        \"trial_length\": trial_length,\n",
    "        \"num_steps\": num_trials * trial_length,\n",
    "        \"model_batch_size\": 32,\n",
    "        \"validation_ratio\": 0.05\n",
    "    }\n",
    "}\n",
    "cfg = omegaconf.OmegaConf.create(cfg_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>Note: </b> This example uses a probabilistic ensemble. You can also use a fully deterministic model with class GaussianMLP by setting ensemble_size=1, and deterministic=True. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a dynamics model\n",
    "\n",
    "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/private/home/lep/.conda/envs/mbrl_pip/lib/python3.8/site-packages/hydra/utils.py:32: UserWarning: `OmegaConf.is_none()` is deprecated, see https://github.com/omry/omegaconf/issues/547\n",
      "  if OmegaConf.is_none(config):\n"
     ]
    }
   ],
   "source": [
    "# Create a 1-D dynamics model for this environment\n",
    "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n",
    "\n",
    "# Create a gym-like environment to encapsulate the model\n",
    "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a replay buffer\n",
    "\n",
    "We can create a replay buffer for this environment an configuration using the following method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# samples stored 200\n"
     ]
    }
   ],
   "source": [
    "common_util.rollout_agent_trajectories(\n",
    "    env,\n",
    "    trial_length, # initial exploration steps\n",
    "    planning.RandomAgent(env),\n",
    "    {}, # keyword arguments to pass to agent.act()\n",
    "    replay_buffer=replay_buffer,\n",
    "    trial_length=trial_length\n",
    ")\n",
    "\n",
    "print(\"# samples stored\", replay_buffer.num_stored)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CEM Agent\n",
    "\n",
    "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_cfg = omegaconf.OmegaConf.create({\n",
    "    # this class evaluates many trajectories and picks the best one\n",
    "    \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n",
    "    \"planning_horizon\": 15,\n",
    "    \"replan_freq\": 1,\n",
    "    \"verbose\": False,\n",
    "    \"action_lb\": \"???\",\n",
    "    \"action_ub\": \"???\",\n",
    "    # this is the optimizer to generate and choose a trajectory\n",
    "    \"optimizer_cfg\": {\n",
    "        \"_target_\": \"mbrl.planning.CEMOptimizer\",\n",
    "        \"num_iterations\": 5,\n",
    "        \"elite_ratio\": 0.1,\n",
    "        \"population_size\": 500,\n",
    "        \"alpha\": 0.1,\n",
    "        \"device\": device,\n",
    "        \"lower_bound\": \"???\",\n",
    "        \"upper_bound\": \"???\",\n",
    "        \"return_mean_elites\": True,\n",
    "    }\n",
    "})\n",
    "\n",
    "agent = planning.create_trajectory_optim_agent_for_model(\n",
    "    model_env,\n",
    "    agent_cfg,\n",
    "    num_particles=20\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running PETS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses = []\n",
    "val_scores = []\n",
    "\n",
    "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n",
    "    train_losses.append(tr_loss)\n",
    "    val_scores.append(val_score.mean().item())   # this returns val score per ensemble model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n",
    "    if not force_update and (_steps_trial % 10 != 0):\n",
    "        return\n",
    "    _axs[0].imshow(_frame)\n",
    "    _axs[0].set_xticks([])\n",
    "    _axs[0].set_yticks([])\n",
    "    _axs[1].clear()\n",
    "    _axs[1].set_xlim([0, num_trials + .1])\n",
    "    _axs[1].set_ylim([0, 200])\n",
    "    _axs[1].set_xlabel(\"Trial\")\n",
    "    _axs[1].set_ylabel(\"Trial reward\")\n",
    "    _axs[1].plot(_all_rewards, 'bs-')\n",
    "    _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n",
    "    display.display(plt.gcf())  \n",
    "    display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n",
    "\n",
    "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x270 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a trainer for the model\n",
    "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n",
    "\n",
    "# Create visualization objects\n",
    "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n",
    "ax_text = axs[0].text(300, 50, \"\")\n",
    "    \n",
    "# Main PETS loop\n",
    "all_rewards = [0]\n",
    "for trial in range(num_trials):\n",
    "    obs = env.reset()    \n",
    "    agent.reset()\n",
    "    \n",
    "    done = False\n",
    "    total_reward = 0.0\n",
    "    steps_trial = 0\n",
    "    update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "    while not done:\n",
    "        # --------------- Model Training -----------------\n",
    "        if steps_trial == 0:\n",
    "            dynamics_model.update_normalizer(replay_buffer.get_all())  # update normalizer stats\n",
    "            \n",
    "            dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n",
    "                replay_buffer,\n",
    "                batch_size=cfg.overrides.model_batch_size,\n",
    "                val_ratio=cfg.overrides.validation_ratio,\n",
    "                ensemble_size=ensemble_size,\n",
    "                shuffle_each_epoch=True,\n",
    "                bootstrap_permutes=False,  # build bootstrap dataset using sampling with replacement\n",
    "            )\n",
    "                \n",
    "            model_trainer.train(\n",
    "                dataset_train, \n",
    "                dataset_val=dataset_val, \n",
    "                num_epochs=50, \n",
    "                patience=50, \n",
    "                callback=train_callback,\n",
    "            )\n",
    "\n",
    "        # --- Doing env step using the agent and adding to model dataset ---\n",
    "        next_obs, reward, done, _ = common_util.step_env_and_add_to_buffer(\n",
    "            env, obs, agent, {}, replay_buffer)\n",
    "            \n",
    "        update_axes(\n",
    "            axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards)\n",
    "        \n",
    "        obs = next_obs\n",
    "        total_reward += reward\n",
    "        steps_trial += 1\n",
    "        \n",
    "        if steps_trial == trial_length:\n",
    "            break\n",
    "    \n",
    "    all_rewards.append(total_reward)\n",
    "\n",
    "update_axes(axs, env.render(mode=\"rgb_array\"), ax_text, trial, steps_trial, all_rewards, force_update=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n",
    "ax[0].plot(train_losses)\n",
    "ax[0].set_xlabel(\"Total training epochs\")\n",
    "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n",
    "ax[1].plot(val_scores)\n",
    "ax[1].set_xlabel(\"Total training epochs\")\n",
    "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Where to learn more about MBRL?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn about the other features of the library, please check out our [documentation](https://facebookresearch.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/pets.py), [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/mbpo.py), and [PlaNet](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/planet.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/main/mbrl/examples/conf)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MBRL v0.1.5",
   "language": "python",
   "name": "mbrl_015"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}